class OuterClass {
    public int data1=111;
    private int data2=2;
    private static final int data3=3;

    static public class JavaInnerClass {   //静态内部类
        public int data4=4;
        private int data5=5;
        private static final int data6=6;

        public void testInner(OuterClass outerClass) {
            System.out.println(outerClass.data1);
            System.out.println(outerClass.data2);
            System.out.println(data3);  //内部类中可以访问外部类的static变量，要访问非静态成员，需要创建对象访问
        }

    }

    class InnerClass2 {    //实例内部类
        private int data1=11111;
        private int data7=7;
        private int data8=8;
        //此时当时外部类加载的时候，这个非静态内部类不会加载
        private static final int data9=9;   //在非静态内部类中不能存在静态成员 ，如果非要存在需要加上final修饰这个变量
        public void testInner2(JavaInnerClass innerClass) {
            System.out.println(data1);   //就近原则，优先访问自己的
            System.out.println(OuterClass.this.data1);  //如果需要访问外部类的同名成员，需要外部类名.this.同名变量名
            System.out.println(data2);
            System.out.println(data3);  //实例内部类能访问到外部类的所有成员
            System.out.println(innerClass.data4);
            System.out.println(innerClass.data5);
            System.out.println(JavaInnerClass.data6);
        }
    }
    interface IAa {
        void func();
    }
    class AA implements IAa {
        @Override
        public void func() {
            System.out.println("hello");
        }
    }

    public void testOuter(JavaInnerClass innerClass,InnerClass2 innerClass2) {
        System.out.println(data1);
        System.out.println(data2);
        System.out.println(data3);
        System.out.println(innerClass.data4);
        System.out.println(innerClass.data5);//外部类可以访问静态内部类的所有成员,包括private封装的成员
        System.out.println(JavaInnerClass.data6);
        System.out.println(innerClass2.data7);
        System.out.println(innerClass2.data8);
        System.out.println(InnerClass2.data9);
    }


    public static void main(String[] args) {
        JavaInnerClass javaInnerClass=new JavaInnerClass();  //静态内部类对象的创建方式
        OuterClass outerClass=new OuterClass();
        javaInnerClass.testInner(outerClass);

        OuterClass.InnerClass2 innerClass2=outerClass.new InnerClass2();  //实例内部类创建对象的方式，比较麻烦，需要外部类的对象，而静态内部类不需要
        innerClass2.testInner2(javaInnerClass);

        new IAa(){     //匿名内部类
            @Override
            public void func() {
                System.out.println("hello");
            }
        }.func();

        outerClass.testOuter(javaInnerClass,innerClass2);

    }
}